home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / ppc-amigaos / include / powerup / ppcpragmas / icon_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-02-28  |  7KB  |  251 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_ICON_H
  4. #define _PPCPRAGMA_ICON_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__ICON_H
  7. #include <powerup/ppcinline/icon.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef ICON_BASE_NAME
  24. #define ICON_BASE_NAME IconBase
  25. #endif /* !ICON_BASE_NAME */
  26.  
  27. #define    AddFreeList(freelist, mem, size)    _AddFreeList(ICON_BASE_NAME, freelist, mem, size)
  28.  
  29. static __inline BOOL
  30. _AddFreeList(void *IconBase, struct FreeList *freelist, APTR mem, unsigned long size)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.a0        =(ULONG) freelist;
  40.     MyCaos.a1        =(ULONG) mem;
  41.     MyCaos.a2        =(ULONG) size;
  42.     MyCaos.caos_Un.Offset    =    (-72);
  43.     MyCaos.a6        =(ULONG) IconBase;    
  44.     return((BOOL)PPCCallOS(&MyCaos));
  45. }
  46.  
  47. #define    BumpRevision(newname, oldname)    _BumpRevision(ICON_BASE_NAME, newname, oldname)
  48.  
  49. static __inline UBYTE *
  50. _BumpRevision(void *IconBase, UBYTE *newname, UBYTE *oldname)
  51. {
  52. struct Caos    MyCaos;
  53.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  54. //    MyCaos.M68kStart    =    NULL;
  55. //    MyCaos.M68kSize        =    0;
  56.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  57. //    MyCaos.PPCStart        =    NULL;
  58. //    MyCaos.PPCSize        =    0;
  59.     MyCaos.a0        =(ULONG) newname;
  60.     MyCaos.a1        =(ULONG) oldname;
  61.     MyCaos.caos_Un.Offset    =    (-108);
  62.     MyCaos.a6        =(ULONG) IconBase;    
  63.     return((UBYTE *)PPCCallOS(&MyCaos));
  64. }
  65.  
  66. #define    DeleteDiskObject(name)    _DeleteDiskObject(ICON_BASE_NAME, name)
  67.  
  68. static __inline BOOL
  69. _DeleteDiskObject(void *IconBase, UBYTE *name)
  70. {
  71. struct Caos    MyCaos;
  72.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  73. //    MyCaos.M68kStart    =    NULL;
  74. //    MyCaos.M68kSize        =    0;
  75.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  76. //    MyCaos.PPCStart        =    NULL;
  77. //    MyCaos.PPCSize        =    0;
  78.     MyCaos.a0        =(ULONG) name;
  79.     MyCaos.caos_Un.Offset    =    (-138);
  80.     MyCaos.a6        =(ULONG) IconBase;    
  81.     return((BOOL)PPCCallOS(&MyCaos));
  82. }
  83.  
  84. #define    FindToolType(toolTypeArray, typeName)    _FindToolType(ICON_BASE_NAME, toolTypeArray, typeName)
  85.  
  86. static __inline UBYTE *
  87. _FindToolType(void *IconBase, UBYTE **toolTypeArray, UBYTE *typeName)
  88. {
  89. struct Caos    MyCaos;
  90.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  91. //    MyCaos.M68kStart    =    NULL;
  92. //    MyCaos.M68kSize        =    0;
  93.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  94. //    MyCaos.PPCStart        =    NULL;
  95. //    MyCaos.PPCSize        =    0;
  96.     MyCaos.a0        =(ULONG) toolTypeArray;
  97.     MyCaos.a1        =(ULONG) typeName;
  98.     MyCaos.caos_Un.Offset    =    (-96);
  99.     MyCaos.a6        =(ULONG) IconBase;    
  100.     return((UBYTE *)PPCCallOS(&MyCaos));
  101. }
  102.  
  103. #define    FreeDiskObject(diskobj)    _FreeDiskObject(ICON_BASE_NAME, diskobj)
  104.  
  105. static __inline void
  106. _FreeDiskObject(void *IconBase, struct DiskObject *diskobj)
  107. {
  108. struct Caos    MyCaos;
  109.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  110. //    MyCaos.M68kStart    =    NULL;
  111. //    MyCaos.M68kSize        =    0;
  112.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  113. //    MyCaos.PPCStart        =    NULL;
  114. //    MyCaos.PPCSize        =    0;
  115.     MyCaos.a0        =(ULONG) diskobj;
  116.     MyCaos.caos_Un.Offset    =    (-90);
  117.     MyCaos.a6        =(ULONG) IconBase;    
  118.     PPCCallOS(&MyCaos);
  119. }
  120.  
  121. #define    FreeFreeList(freelist)    _FreeFreeList(ICON_BASE_NAME, freelist)
  122.  
  123. static __inline void
  124. _FreeFreeList(void *IconBase, struct FreeList *freelist)
  125. {
  126. struct Caos    MyCaos;
  127.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  128. //    MyCaos.M68kStart    =    NULL;
  129. //    MyCaos.M68kSize        =    0;
  130.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  131. //    MyCaos.PPCStart        =    NULL;
  132. //    MyCaos.PPCSize        =    0;
  133.     MyCaos.a0        =(ULONG) freelist;
  134.     MyCaos.caos_Un.Offset    =    (-54);
  135.     MyCaos.a6        =(ULONG) IconBase;    
  136.     PPCCallOS(&MyCaos);
  137. }
  138.  
  139. #define    GetDefDiskObject(type)    _GetDefDiskObject(ICON_BASE_NAME, type)
  140.  
  141. static __inline struct DiskObject *
  142. _GetDefDiskObject(void *IconBase, long type)
  143. {
  144. struct Caos    MyCaos;
  145.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  146. //    MyCaos.M68kStart    =    NULL;
  147. //    MyCaos.M68kSize        =    0;
  148.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  149. //    MyCaos.PPCStart        =    NULL;
  150. //    MyCaos.PPCSize        =    0;
  151.     MyCaos.d0        =(ULONG) type;
  152.     MyCaos.caos_Un.Offset    =    (-120);
  153.     MyCaos.a6        =(ULONG) IconBase;    
  154.     return((struct DiskObject *)PPCCallOS(&MyCaos));
  155. }
  156.  
  157. #define    GetDiskObject(name)    _GetDiskObject(ICON_BASE_NAME, name)
  158.  
  159. static __inline struct DiskObject *
  160. _GetDiskObject(void *IconBase, UBYTE *name)
  161. {
  162. struct Caos    MyCaos;
  163.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  164. //    MyCaos.M68kStart    =    NULL;
  165. //    MyCaos.M68kSize        =    0;
  166.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  167. //    MyCaos.PPCStart        =    NULL;
  168. //    MyCaos.PPCSize        =    0;
  169.     MyCaos.a0        =(ULONG) name;
  170.     MyCaos.caos_Un.Offset    =    (-78);
  171.     MyCaos.a6        =(ULONG) IconBase;    
  172.     return((struct DiskObject *)PPCCallOS(&MyCaos));
  173. }
  174.  
  175. #define    GetDiskObjectNew(name)    _GetDiskObjectNew(ICON_BASE_NAME, name)
  176.  
  177. static __inline struct DiskObject *
  178. _GetDiskObjectNew(void *IconBase, UBYTE *name)
  179. {
  180. struct Caos    MyCaos;
  181.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  182. //    MyCaos.M68kStart    =    NULL;
  183. //    MyCaos.M68kSize        =    0;
  184.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  185. //    MyCaos.PPCStart        =    NULL;
  186. //    MyCaos.PPCSize        =    0;
  187.     MyCaos.a0        =(ULONG) name;
  188.     MyCaos.caos_Un.Offset    =    (-132);
  189.     MyCaos.a6        =(ULONG) IconBase;    
  190.     return((struct DiskObject *)PPCCallOS(&MyCaos));
  191. }
  192.  
  193. #define    MatchToolValue(typeString, value)    _MatchToolValue(ICON_BASE_NAME, typeString, value)
  194.  
  195. static __inline BOOL
  196. _MatchToolValue(void *IconBase, UBYTE *typeString, UBYTE *value)
  197. {
  198. struct Caos    MyCaos;
  199.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  200. //    MyCaos.M68kStart    =    NULL;
  201. //    MyCaos.M68kSize        =    0;
  202.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  203. //    MyCaos.PPCStart        =    NULL;
  204. //    MyCaos.PPCSize        =    0;
  205.     MyCaos.a0        =(ULONG) typeString;
  206.     MyCaos.a1        =(ULONG) value;
  207.     MyCaos.caos_Un.Offset    =    (-102);
  208.     MyCaos.a6        =(ULONG) IconBase;    
  209.     return((BOOL)PPCCallOS(&MyCaos));
  210. }
  211.  
  212. #define    PutDefDiskObject(diskObject)    _PutDefDiskObject(ICON_BASE_NAME, diskObject)
  213.  
  214. static __inline BOOL
  215. _PutDefDiskObject(void *IconBase, struct DiskObject *diskObject)
  216. {
  217. struct Caos    MyCaos;
  218.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  219. //    MyCaos.M68kStart    =    NULL;
  220. //    MyCaos.M68kSize        =    0;
  221.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  222. //    MyCaos.PPCStart        =    NULL;
  223. //    MyCaos.PPCSize        =    0;
  224.     MyCaos.a0        =(ULONG) diskObject;
  225.     MyCaos.caos_Un.Offset    =    (-126);
  226.     MyCaos.a6        =(ULONG) IconBase;    
  227.     return((BOOL)PPCCallOS(&MyCaos));
  228. }
  229.  
  230. #define    PutDiskObject(name, diskobj)    _PutDiskObject(ICON_BASE_NAME, name, diskobj)
  231.  
  232. static __inline BOOL
  233. _PutDiskObject(void *IconBase, UBYTE *name, struct DiskObject *diskobj)
  234. {
  235. struct Caos    MyCaos;
  236.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  237. //    MyCaos.M68kStart    =    NULL;
  238. //    MyCaos.M68kSize        =    0;
  239.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  240. //    MyCaos.PPCStart        =    NULL;
  241. //    MyCaos.PPCSize        =    0;
  242.     MyCaos.a0        =(ULONG) name;
  243.     MyCaos.a1        =(ULONG) diskobj;
  244.     MyCaos.caos_Un.Offset    =    (-84);
  245.     MyCaos.a6        =(ULONG) IconBase;    
  246.     return((BOOL)PPCCallOS(&MyCaos));
  247. }
  248.  
  249. #endif /* SASC Pragmas */
  250. #endif /* !_PPCPRAGMA_ICON_H */
  251.